home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / include / aio.h < prev    next >
C/C++ Source or Header  |  2009-10-07  |  8KB  |  247 lines
  1. /* Copyright (C) 1996-2000,2003,2004,2007 Free Software Foundation, Inc.
  2.    This file is part of the GNU C Library.
  3.  
  4.    The GNU C Library is free software; you can redistribute it and/or
  5.    modify it under the terms of the GNU Lesser General Public
  6.    License as published by the Free Software Foundation; either
  7.    version 2.1 of the License, or (at your option) any later version.
  8.  
  9.    The GNU C Library is distributed in the hope that it will be useful,
  10.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12.    Lesser General Public License for more details.
  13.  
  14.    You should have received a copy of the GNU Lesser General Public
  15.    License along with the GNU C Library; if not, write to the Free
  16.    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  17.    02111-1307 USA.  */
  18.  
  19. /*
  20.  * ISO/IEC 9945-1:1996 6.7: Asynchronous Input and Output
  21.  */
  22.  
  23. #ifndef _AIO_H
  24. #define _AIO_H    1
  25.  
  26. #include <features.h>
  27. #include <fcntl.h>
  28. #include <signal.h>
  29. #include <time.h>
  30. #include <sys/types.h>
  31.  
  32. __BEGIN_DECLS
  33.  
  34. /* Asynchronous I/O control block.  */
  35. struct aiocb
  36. {
  37.   int aio_fildes;        /* File desriptor.  */
  38.   int aio_lio_opcode;        /* Operation to be performed.  */
  39.   int aio_reqprio;        /* Request priority offset.  */
  40.   volatile void *aio_buf;    /* Location of buffer.  */
  41.   size_t aio_nbytes;        /* Length of transfer.  */
  42.   struct sigevent aio_sigevent;    /* Signal number and value.  */
  43.  
  44.   /* Internal members.  */
  45.   struct aiocb *__next_prio;
  46.   int __abs_prio;
  47.   int __policy;
  48.   int __error_code;
  49.   __ssize_t __return_value;
  50.  
  51. #ifndef __USE_FILE_OFFSET64
  52.   __off_t aio_offset;        /* File offset.  */
  53.   char __pad[sizeof (__off64_t) - sizeof (__off_t)];
  54. #else
  55.   __off64_t aio_offset;        /* File offset.  */
  56. #endif
  57.   char __unused[32];
  58. };
  59.  
  60. /* The same for the 64bit offsets.  Please note that the members aio_fildes
  61.    to __return_value have to be the same in aiocb and aiocb64.  */
  62. #ifdef __USE_LARGEFILE64
  63. struct aiocb64
  64. {
  65.   int aio_fildes;        /* File desriptor.  */
  66.   int aio_lio_opcode;        /* Operation to be performed.  */
  67.   int aio_reqprio;        /* Request priority offset.  */
  68.   volatile void *aio_buf;    /* Location of buffer.  */
  69.   size_t aio_nbytes;        /* Length of transfer.  */
  70.   struct sigevent aio_sigevent;    /* Signal number and value.  */
  71.  
  72.   /* Internal members.  */
  73.   struct aiocb *__next_prio;
  74.   int __abs_prio;
  75.   int __policy;
  76.   int __error_code;
  77.   __ssize_t __return_value;
  78.  
  79.   __off64_t aio_offset;        /* File offset.  */
  80.   char __unused[32];
  81. };
  82. #endif
  83.  
  84.  
  85. #ifdef __USE_GNU
  86. /* To customize the implementation one can use the following struct.
  87.    This implementation follows the one in Irix.  */
  88. struct aioinit
  89.   {
  90.     int aio_threads;        /* Maximal number of threads.  */
  91.     int aio_num;        /* Number of expected simultanious requests. */
  92.     int aio_locks;        /* Not used.  */
  93.     int aio_usedba;        /* Not used.  */
  94.     int aio_debug;        /* Not used.  */
  95.     int aio_numusers;        /* Not used.  */
  96.     int aio_idle_time;        /* Number of seconds before idle thread
  97.                    terminates.  */
  98.     int aio_reserved;
  99.   };
  100. #endif
  101.  
  102.  
  103. /* Return values of cancelation function.  */
  104. enum
  105. {
  106.   AIO_CANCELED,
  107. #define AIO_CANCELED AIO_CANCELED
  108.   AIO_NOTCANCELED,
  109. #define AIO_NOTCANCELED AIO_NOTCANCELED
  110.   AIO_ALLDONE
  111. #define AIO_ALLDONE AIO_ALLDONE
  112. };
  113.  
  114.  
  115. /* Operation codes for `aio_lio_opcode'.  */
  116. enum
  117. {
  118.   LIO_READ,
  119. #define LIO_READ LIO_READ
  120.   LIO_WRITE,
  121. #define LIO_WRITE LIO_WRITE
  122.   LIO_NOP
  123. #define LIO_NOP LIO_NOP
  124. };
  125.  
  126.  
  127. /* Synchronization options for `lio_listio' function.  */
  128. enum
  129. {
  130.   LIO_WAIT,
  131. #define LIO_WAIT LIO_WAIT
  132.   LIO_NOWAIT
  133. #define LIO_NOWAIT LIO_NOWAIT
  134. };
  135.  
  136.  
  137. /* Allow user to specify optimization.  */
  138. #ifdef __USE_GNU
  139. extern void aio_init (__const struct aioinit *__init) __THROW __nonnull ((1));
  140. #endif
  141.  
  142.  
  143. #ifndef __USE_FILE_OFFSET64
  144. /* Enqueue read request for given number of bytes and the given priority.  */
  145. extern int aio_read (struct aiocb *__aiocbp) __THROW __nonnull ((1));
  146. /* Enqueue write request for given number of bytes and the given priority.  */
  147. extern int aio_write (struct aiocb *__aiocbp) __THROW __nonnull ((1));
  148.  
  149. /* Initiate list of I/O requests.  */
  150. extern int lio_listio (int __mode,
  151.                struct aiocb *__const __list[__restrict_arr],
  152.                int __nent, struct sigevent *__restrict __sig)
  153.   __THROW __nonnull ((2));
  154.  
  155. /* Retrieve error status associated with AIOCBP.  */
  156. extern int aio_error (__const struct aiocb *__aiocbp) __THROW __nonnull ((1));
  157. /* Return status associated with AIOCBP.  */
  158. extern __ssize_t aio_return (struct aiocb *__aiocbp) __THROW __nonnull ((1));
  159.  
  160. /* Try to cancel asynchronous I/O requests outstanding against file
  161.    descriptor FILDES.  */
  162. extern int aio_cancel (int __fildes, struct aiocb *__aiocbp) __THROW;
  163.  
  164. /* Suspend calling thread until at least one of the asynchronous I/O
  165.    operations referenced by LIST has completed.
  166.  
  167.    This function is a cancellation point and therefore not marked with
  168.    __THROW.  */
  169. extern int aio_suspend (__const struct aiocb *__const __list[], int __nent,
  170.             __const struct timespec *__restrict __timeout)
  171.   __nonnull ((1));
  172.  
  173. /* Force all operations associated with file desriptor described by
  174.    `aio_fildes' member of AIOCBP.  */
  175. extern int aio_fsync (int __operation, struct aiocb *__aiocbp)
  176.   __THROW __nonnull ((2));
  177. #else
  178. # ifdef __REDIRECT_NTH
  179. extern int __REDIRECT_NTH (aio_read, (struct aiocb *__aiocbp), aio_read64)
  180.   __nonnull ((1));
  181. extern int __REDIRECT_NTH (aio_write, (struct aiocb *__aiocbp), aio_write64)
  182.   __nonnull ((1));
  183.  
  184. extern int __REDIRECT_NTH (lio_listio,
  185.                (int __mode,
  186.                 struct aiocb *__const __list[__restrict_arr],
  187.                 int __nent, struct sigevent *__restrict __sig),
  188.                lio_listio64) __nonnull ((2));
  189.  
  190. extern int __REDIRECT_NTH (aio_error, (__const struct aiocb *__aiocbp),
  191.                aio_error64) __nonnull ((1));
  192. extern __ssize_t __REDIRECT_NTH (aio_return, (struct aiocb *__aiocbp),
  193.                  aio_return64) __nonnull ((1));
  194.  
  195. extern int __REDIRECT_NTH (aio_cancel,
  196.                (int __fildes, struct aiocb *__aiocbp),
  197.                aio_cancel64);
  198.  
  199. extern int __REDIRECT_NTH (aio_suspend,
  200.                (__const struct aiocb *__const __list[], int __nent,
  201.                 __const struct timespec *__restrict __timeout),
  202.                aio_suspend64) __nonnull ((1));
  203.  
  204. extern int __REDIRECT_NTH (aio_fsync,
  205.                (int __operation, struct aiocb *__aiocbp),
  206.                aio_fsync64) __nonnull ((2));
  207.  
  208. # else
  209. #  define aio_read aio_read64
  210. #  define aio_write aio_write64
  211. #  define lio_listio lio_listio64
  212. #  define aio_error aio_error64
  213. #  define aio_return aio_return64
  214. #  define aio_cancel aio_cancel64
  215. #  define aio_suspend aio_suspend64
  216. #  define aio_fsync aio_fsync64
  217. # endif
  218. #endif
  219.  
  220. #ifdef __USE_LARGEFILE64
  221. extern int aio_read64 (struct aiocb64 *__aiocbp) __THROW __nonnull ((1));
  222. extern int aio_write64 (struct aiocb64 *__aiocbp) __THROW __nonnull ((1));
  223.  
  224. extern int lio_listio64 (int __mode,
  225.              struct aiocb64 *__const __list[__restrict_arr],
  226.              int __nent, struct sigevent *__restrict __sig)
  227.   __THROW __nonnull ((2));
  228.  
  229. extern int aio_error64 (__const struct aiocb64 *__aiocbp)
  230.   __THROW __nonnull ((1));
  231. extern __ssize_t aio_return64 (struct aiocb64 *__aiocbp)
  232.   __THROW __nonnull ((1));
  233.  
  234. extern int aio_cancel64 (int __fildes, struct aiocb64 *__aiocbp) __THROW;
  235.  
  236. extern int aio_suspend64 (__const struct aiocb64 *__const __list[], int __nent,
  237.               __const struct timespec *__restrict __timeout)
  238.   __THROW __nonnull ((1));
  239.  
  240. extern int aio_fsync64 (int __operation, struct aiocb64 *__aiocbp)
  241.   __THROW __nonnull ((2));
  242. #endif
  243.  
  244. __END_DECLS
  245.  
  246. #endif /* aio.h */
  247.